package com.fire.core.util;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpClientParams;
import org.apache.commons.httpclient.protocol.Protocol;


/**
 * 公共工具类
 * 
 * @author Pollock
 *
 */
public class Public {

	private static final String HTTPS = "https";
	
	/**  
     * 将一个 Map 对象转化为一个 JavaBean  
     * @param clazz 要转化的类型  
     * @param map 包含属性值的 map  
     * @return 转化出来的 JavaBean 对象  
     * @throws IntrospectionException 如果分析类属性失败  
     * @throws IllegalAccessException 如果实例化 JavaBean 失败  
     * @throws InstantiationException 如果实例化 JavaBean 失败  
     * @throws InvocationTargetException 如果调用属性的 setter 方法失败  
     */    
    @SuppressWarnings("rawtypes")    
    public static <T> T toBean(Class<T> clazz, Map map) {    
        T obj = null;    
        try {    
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz);    
            obj = clazz.newInstance(); // 创建 JavaBean 对象    
    
            // 给 JavaBean 对象的属性赋值    
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();    
            for (int i = 0; i < propertyDescriptors.length; i++) {    
                PropertyDescriptor descriptor = propertyDescriptors[i];    
                String propertyName = descriptor.getName();    
                if (map.containsKey(propertyName)) {    
                    // 下面一句可以 try 起来，这样当一个属性赋值失败的时候就不会影响其他属性赋值。    
                    Object value = map.get(propertyName);    
                    if ("".equals(value)) {    
                        value = null;    
                    }    
                    Object[] args = new Object[1];    
                    args[0] = value;    
                    try {    
                        descriptor.getWriteMethod().invoke(obj, args);    
                    } catch (InvocationTargetException e) {    
                        System.out.println("字段映射失败");    
                    }    
                }    
            }    
        } catch (IllegalAccessException e) {    
            System.out.println("实例化 JavaBean 失败");    
        } catch (IntrospectionException e) {    
            System.out.println("分析类属性失败");    
        } catch (IllegalArgumentException e) {    
            System.out.println("映射错误");    
        } catch (InstantiationException e) {    
            System.out.println("实例化 JavaBean 失败");    
        }    
        return (T) obj;    
    }    
    
    /**  
     * 将一个 JavaBean 对象转化为一个 Map  
     * @param bean 要转化的JavaBean 对象  
     * @return 转化出来的 Map 对象  
     * @throws IntrospectionException 如果分析类属性失败  
     * @throws IllegalAccessException 如果实例化 JavaBean 失败  
     * @throws InvocationTargetException 如果调用属性的 setter 方法失败  
     */    
    @SuppressWarnings("rawtypes")    
    public static Map toMap(Object bean) {    
        Class<? extends Object> clazz = bean.getClass();    
        Map<Object, Object> returnMap = new HashMap<Object, Object>();    
        BeanInfo beanInfo = null;    
        try {    
            beanInfo = Introspector.getBeanInfo(clazz);    
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();    
            for (int i = 0; i < propertyDescriptors.length; i++) {    
                PropertyDescriptor descriptor = propertyDescriptors[i];    
                String propertyName = descriptor.getName();    
                if (!"class".equals(propertyName)) {    
                    Method readMethod = descriptor.getReadMethod();    
                    Object result = null;    
                    result = readMethod.invoke(bean, new Object[0]);    
                    if (null != propertyName) {    
                        propertyName = propertyName.toString();    
                    }    
                    if (null != result) {    
                        result = result.toString();    
                    }    
                    returnMap.put(propertyName, result);    
                }    
            }    
        } catch (IntrospectionException e) {    
            System.out.println("分析类属性失败");    
        } catch (IllegalAccessException e) {    
            System.out.println("实例化 JavaBean 失败");    
        } catch (IllegalArgumentException e) {    
            System.out.println("映射错误");    
        } catch (InvocationTargetException e) {    
            System.out.println("调用属性的 setter 方法失败");    
        }    
        return returnMap;    
    }  
    
    /**
     * 将map转成json字符串
     * @param map
     * @return
     */
    public static String mapToJson(Map<String, String> map) {  
        Set<String> keys = map.keySet();  
        String key = "";  
        String value = "";  
        StringBuffer jsonBuffer = new StringBuffer();  
        jsonBuffer.append("{");  
        for (Iterator<String> it = keys.iterator(); it.hasNext();) {  
            key = (String) it.next();  
            value = map.get(key);  
            jsonBuffer.append(key + ":" +"\""+ value+"\"");  
            if (it.hasNext()) {  
                jsonBuffer.append(",");  
            }  
        }  
        jsonBuffer.append("}");  
        return jsonBuffer.toString();  
    } 
    
    public static String request(String in, String httpUrl, int timeout)throws Exception {
		PostMethod postmethod = new PostMethod(httpUrl);
		URL url = new URL(httpUrl);
		if(url.getProtocol().equals(HTTPS)){
            Protocol https = new Protocol(HTTPS, new SslProtocolSocketFactory(), url.getPort()==-1?80:url.getPort());
            Protocol.registerProtocol(HTTPS, https);
        }
		String responseBodyAsString = "";
		try {
			postmethod.setRequestBody(in);
			postmethod.setRequestHeader("Content-type", "application/json;charset=UTF-8");
			
			System.out.println("请求服务开始...");
			System.out.println("转发bia-middle服务URL=" + url);
			
			// 指定请求内容的类型
			HttpClient httpclient = new HttpClient();
			HttpClientParams httparams = new HttpClientParams();
			// int timeout = 0;
			if (timeout <= 0) {
				timeout = 180* 1000;
			}
			httparams.setSoTimeout(timeout);
			httpclient.setParams(httparams);
			int result = httpclient.executeMethod(postmethod);
			System.out.println("转发服务结束,返回结果代码=" + result);
			byte[] cont = postmethod.getResponseBody();
			String re = new String(cont, "UTF-8");
			postmethod.releaseConnection();
			postmethod = null;
			responseBodyAsString = re;
		}catch (Exception e) {
			throw e;
		} finally {
			if (postmethod != null) {
				try {
					postmethod.releaseConnection();
					postmethod = null;
				} catch (Exception e1) {
					
				}
			}
		}
		return responseBodyAsString;
	}
    
	/**
	 * 
	 * 说明： 根据url 截取地址
	 * 
	 * @param url 字符串url
	 * 
	 * @return 参数字符串
	 */
	public static String getUrl(String url) {

		StringBuffer result = new StringBuffer();
		String[] str = url.replaceAll("https://", "").split("/");
		if (str != null ){
			for (int i = 1; i < str.length; i++) {
				result.append("/"+str[i]);
			}
		}
		return String.valueOf(result);
	}
	
	/**
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		
	}
}
